Amiga Tools 3/Amiga Tools 3.iso/grafik/raytracing/rayshade-4.0.6.3/inetray/inetray.start.c

C/C++ Source or Header | 1993-08-17 | 5KB | 185 lines

/*======================================================================
            I N E T R A Y . S T A R T . C
                    doc: Fri Mar 13 12:21:13 1992
                    dlm: Tue Aug 17 09:52:44 1993
                    (c) 1992 ant@julia
                    uE-Info: 27 6 T 0 0 72 2 2 8 ofnI
======================================================================*/

/* Note: Up to version 1.1.0 more than 1 servers could be started by
         this program. As of 1.1.1 handling of more than one sever has
         been moved to rpc.inetrayd for consistency. Variables have,
         however, not been renamed and the structure still reflects the
         olde approach. */

#define        DAEMON            /* run as daemon */

#include    <stdio.h>
#include    <signal.h>
#include    <syslog.h>
#include    <sys/types.h>
#include    <sys/ioctl.h>
#include    <sys/stat.h>
#include    <sys/param.h>
#include    <rpc/rpc.h>
#ifndef TIOCNOTTY
#include    <termios.h>
#endif
#include    "inetray.h"
#include    "config.h"
#include    "common.h"
#include    "stderr.h"
#include    "inetray.start.h"

static int     nRunning = 0;        /* number of running servers */
static char     *av0 = NULL;        /* server path */

extern void starter_1();        /* generated dispatch routine */

static void cleanUp(sig)        /* clean up on kill */
int sig;
{
    if (sig >= 0)
        SYSLOG(LOG_ERR,"Shut down due to signal #%d",sig);
    (void) pmap_unset(STARTER, IRSV1);
    CLOSELOG();
    if (sig >= 0) exit(sig);
    else          exit(1);
}

main(ac,av)
int ac; char *av[];
{
    int     i,pid,sock,proto,rpcStat;
    char    name[MAXHOSTNAMELEN];
    register SVCXPRT *transp;
    struct stat buf;

    OPENLOG(av[0]);            /* set up syslog */

    for (i=0; i<NSIG; i++)        /* clean termination */
        signal(i,cleanUp);

    if (gethostname(name,MAXHOSTNAMELEN) < 0) {
        perror("gethostname");
        cleanUp(-1);
    }
    rpcStat = callrpc(name,STARTER,IRSV1,0,xdr_void,NULL,xdr_void,NULL);
    if (rpcStat == RPC_SUCCESS) {
        fprintf(stderr,"%s already running on %s\n",av[0],name);
        CLOSELOG();
        exit(1);
    } else if (rpcStat != RPC_PROGNOTREGISTERED &&
           rpcStat != RPC_TIMEDOUT) {
        fprintf(stderr,"callrpc(%s,0) ",name);
        clnt_perrno(rpcStat);
        fprintf(stderr,"\n");
        cleanUp(-1);
    }

    if (ac != 2) {
        fprintf(stderr,"Usage: %s <executable>\n",av[0]);
        cleanUp(-1);
    }
    av0 = av[1];            /* set server path */
    if (stat(av0,&buf) < 0) {
        perror("stat: cannot find executable");
        cleanUp(-1);
    }

    signal(SIGIO,SIG_IGN);        /* rpc.inetrayd uses this */
    signal(SIGPIPE,SIG_IGN);    /* rpc.inetrayd uses this */

#ifdef DAEMON
    pid = fork();
        if (pid < 0) {
                perror("cannot fork");
                cleanUp(-1);
        }
        if (pid) exit(0);
        for (i = 0 ; i < 20; i++)
                (void) close(i);
        i = open("/dev/console", 2);
        (void) dup2(i, 1);
        (void) dup2(i, 2);
#ifndef KEEPTTY_QUIRK
        i = open("/dev/tty", 2);
        if (i >= 0) {
                (void) ioctl(i, TIOCNOTTY, (char *)NULL);
                (void) close(i);
        }
#endif
#endif
    sock = RPC_ANYSOCK;
    proto = IPPROTO_UDP;
    (void) pmap_unset(STARTER, IRSV1);

    transp = svcudp_create(sock);
    if (transp == NULL) {
        SYSLOG(LOG_ERR,"cannot create udp service.");
        cleanUp(-1);
    }
    if (!svc_register(transp, STARTER, IRSV1, starter_1, proto)) {
        SYSLOG(LOG_ERR,"unable to register (STARTER, IRSV1, udp).");
        cleanUp(-1);
    }
    svc_run();
    SYSLOG(LOG_ERR,"svc_run returned");
    cleanUp(-1);
    /* NOTREACHED */
}

static void funeral()                /* bury dead children */
{
    int    status;

#ifndef DAEMON
    printf("first child died!\n");
#endif
    signal(SIGCHLD,SIG_DFL);        /* wait for all now */
    while (nRunning > 0) {
        wait(&status);            /* moment of rememberance */
#ifndef DAEMON
        printf("child returnded status %d\n",status);
#endif
        if (status != 0)
            SYSLOG(LOG_ERR,"child returned status %d",status);
        nRunning--;            /* accounting */
    }
#ifndef DAEMON
    printf("all children died!\n");
#endif
}

void *start_1()                    /* start # of servers */
{
    int    i,pid;
    static char result;

#ifndef DAEMON
    printf("START request received...\n");
#endif
    if (nRunning != 0)            /* already servicing */
        return;
    signal(SIGCHLD,funeral);        /* wait for children */
    pid = fork();
    if (pid < 0) {
        SYSLOG(LOG_ERR,"fork: %m");
        cleanUp(-1);
    }
    if (pid == 0) {                /* worker */
#ifndef DAEMON
        printf("execl: %s rpc.inetrayd STARTER\n",av0);
#endif
        if (execl(av0,"rpc.inetrayd","STARTER",NULL) < 0) {
            SYSLOG(LOG_ERR,"execl: %m");
            cleanUp(-1);
        }
    }
#ifndef DAEMON
    printf("pid %d forked...\n",pid);
#endif
    nRunning++;                /* one started */
}